Service Oriented Architecture (SOA) is a computer application integration architecture that is based on a concept of an application service. An application service (hereinafter “service”) typically encapsulates a business function, such as processing of supplied data in accordance with a predetermined business process, and provides platform independent functionality between heterogeneous applications. The service functionality is specified via an implementation independent service interface definition, such as a Web Services Description Language (WSDL). As an example of a service, a thin client application implemented on a JavaScript platform requests user authentication and supplies user credentials to an authentication service executed by one or more server applications implemented on a COBOL platform. Thus, the service may be provided by one or more service provider applications that process the service request in accordance with their specific technology implementation and provide the results of the service execution back to a requesting, or service consumer, application per service definition. The service consumer application, in turn, may be implemented on a technology platform that is different from the service provider application. The service consumer and service provider applications are loosely coupled through the service interface while hiding the implementation details.
In some SOA implementations, services are invoked through messaging middleware that relays service messages between service consumer and service provider applications using a message transport protocol, such as SOAP. The use of messaging middleware provides flexibility in implementing and maintaining the applications interacting via a service contract by removing a direct connection that is otherwise present in a point-to-point communication between the consumer and provider applications. This results in a logical isolation of the service consumer and service provider service interfaces and further simplifies independent development. However, it also results in a performance bottleneck and, in case of proprietary middleware, reduces interoperability.
Typical messaging middleware for communicating the service messages involves using a single proprietary canonical message format for relaying messages between the service consumer and service provider applications. Such an implementation of a service bus architecture degrades performance and increases the cost by requiring frequent transformations of service message formats into a canonical service bus format in order to relay the messages between applications.